{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 第2章 卷积"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.1 简介"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在如今计算机视觉领域，卷积（convolution）可能是出现得最频繁的术语。当然这是因为卷积神经网络被广泛地用于解决多种计算机视觉任务，已经成为计算机视觉领域的一种默认的工具。但是卷积这个术语并不来自于计算机科学领域，而是来自于信号处理领域。卷积是信号处理中的一个重要操作，用于计算线性系统对输入信号的输出响应。什么是卷积呢？顾名思义，就是先“卷”，再“积”。用专业术语来说，卷积的输入是两个函数，一个为输入信号函数，另一个为系统函数，卷积操作先将一个函数翻转（如图 2-1、图 2-2），然后将其对另一个函数进行滑动叠加，最后得到输出结果（如图 2-3）。在函数连续的情况下，叠加指的是对两个函数的乘积求积分；而在离散情况下是对函数加权求和，为简单起见我们统一称之为叠加。\n",
    "\n",
    "\n",
    "\n",
    "<center>\n",
    "    <img style=\"border-radius: 0.3125em;\" \n",
    "    src=\"1.png\" width=500>\n",
    "    <br>\n",
    "    <div style=\"color:orange; \n",
    "    display: inline-block;\n",
    "    color: #999;\n",
    "    padding: 2px;\">图2-1 卷积的输入函数与系统函数</div>\n",
    "</center>\n",
    "\n",
    "\n",
    "<center>\n",
    "    <img style=\"border-radius: 0.3125em;\" \n",
    "    src=\"2.png\" width=500>\n",
    "    <br>\n",
    "    <div style=\"color:orange; \n",
    "    display: inline-block;\n",
    "    color: #999;\n",
    "    padding: 2px;\">图2-2 将系统函数翻转</div>\n",
    "</center>\n",
    "\n",
    "\n",
    "\n",
    "<center>\n",
    "    <img style=\"border-radius: 0.3125em;\" \n",
    "    src=\"7.png\" width=500>\n",
    "    <br>\n",
    "    <div style=\"color:orange; \n",
    "    display: inline-block;\n",
    "    color: #999;\n",
    "    padding: 2px;\">图2-3 滑动叠加求和的结果</div>\n",
    "</center>\n",
    "\n",
    "\n",
    "那么卷积这样一个操作有什么意义呢？为什么要先对输入的函数进行翻转呢？信号处理的教材通常会这样解释：卷积的结果不仅仅和当前输入的信号响应值有关，也和该信号在过去所有时刻的输入响应值有关系。这表明卷积不仅仅考虑当下的情况，也考虑过去时刻的情况，它是一种对相应效果的累积，所以有一个先“卷”再“积”的过程。这么描述仍然很抽象，我们举一个实际生活中的例子。试想你站在一个池塘边，往池塘里扔石子。扔一颗石子，池塘里就会产生水波，然后慢慢衰退，水面重新平静。这里扔石子就是输入信号，产生的水波就是对输入的响应。那么如果按一定速度不停地往池塘中扔石子呢？这种情况下，在水面上某处某一时刻的水波的大小如何计算？根据常识，我们知道当前时刻某处的水波大小不但和当前时刻扔的石子产生的水波有关，还和之前所有扔的石子产生的水波有关，是这些水波的累积结果。这便是先“卷”再“积”的过程，“卷”考虑了与当前输入相关的所有输入，而“积”则把这些输入的效果进行叠加。\n",
    "\n",
    "类似的，在图像处理中，卷积的计算是把每个像素周边相关的像素进行某种加权叠加，考虑了每个像素周边的信息，从而提取图像中的特征，这也为图像识别等计算机视觉任务打下了基础。\n",
    "\n",
    "在这一章节中，我们以一维卷积为引子，介绍卷积的数学定义与代码实现，然后推广到二维卷积。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.2 一维卷积"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "从数学上来说，卷积和加减乘除一样是一种运算，其运算的根本操作是将两个函数($f$和$k$)的其中一个先平移，然后再与另一个函数相称后的累加和。这个运算过程中，因为涉及到积分或者级数的操作，所以看起来很复杂。对于定义在连续域的函数，根据卷积的定义，一维卷积的公式如下：\n",
    "\n",
    "$$g(x) = f(x) * k(x) = \\int f(\\tau)k(x-\\tau)d\\tau$$\n",
    "\n",
    "在上式中，一维卷积的输入是一个一维信号$f(x)$和一个一维卷积核$k(x)$，在信号与系统中，$f(x)$是输入信号函数，$k(x)$是系统函数。我们可以很容易的看出，卷积是在（$-\\infty, \\infty$）上对$\\tau$求积分，积分对象为$f(\\tau)$和$k(x-\\tau)$的乘积。需要注意的是，等式右边只有$k(x-\\tau)$中提及了$x$，其余部分都在关注$\\tau$。\n",
    "\n",
    "\n",
    "根据连续函数一维卷积的公式，我们可以得出卷积操作的计算步骤如下：\n",
    "\n",
    "1. 变换：改变输入函数的横坐标，自变量由$x$变成$\\tau$；\n",
    "2. 反转：将其中一个函数反转；\n",
    "3. 平移：反转后的函数随变量$\\tau$平移，得到$k(x-\\tau)$。若$\\tau>0$，则向右平移，反之向左平移；\n",
    "4. 相乘：将$f(\\tau)$和$k(x-\\tau)$相乘；\n",
    "5. 积分：$f(\\tau)$和$k(x-\\tau)$乘积曲线下的面积即为在$x$位置的卷积值。\n",
    "\n",
    "连续函数的一维卷积在音频处理等方面具有举足轻重的地位。但是，通常计算机所能处理的信号并不是连续的而是离散的，因此，接下来我们介绍离散型函数的一维卷积。\n",
    "\n",
    "根据卷积的定义，离散函数的一维卷积公式如下：\n",
    "\n",
    "$$g_n[x] = f_n[x] * k_n[x] = \\sum_{\\tau} f_n[\\tau]k_n[x-\\tau]$$\n",
    "\n",
    "其中，与连续函数一维卷积不同的是，输入信号和卷积核是$f_n[x](k_n[x])$而非$f(x)(k(x))$，说明它们是离散的函数（通常可用数组表示），而积分变成了求和。卷积核的长度一般是奇数，这是为了对称而设计的。通常情况下，输入信号$f_n[x]$的长度远远大于卷积核$k_n[x]$的长度。图 2-4所示是离散函数一维卷积的计算过程。\n",
    "\n",
    "<center>\n",
    "    <img style=\"border-radius: 0.3125em;\" \n",
    "    src=\"example.png\" width=500>\n",
    "    <br>\n",
    "    <div style=\"color:orange; \n",
    "    display: inline-block;\n",
    "    color: #999;\n",
    "    padding: 2px;\">图2-4 离散函数卷积的示意 </div>\n",
    "</center>\n",
    "\n",
    "\n",
    "由上图不难得出，对于离散变量，卷积可以理解为“卷和”，即相乘之后累加求和。除此之外，不知道大家是否注意到输出信号的长度和输入信号、卷积核之间的关系？\n",
    "\n",
    "假设输入信号长度为$m$，卷积核长度为$n$，按照图示方法，我们可以很容易的得到输出信号的长度为$m-n+1$。但这是不是意味着对一个输入信号反复卷积，它的输出长度将会越来越小？\n",
    "\n",
    "实际上，这种情况是确实可能存在的。因此，为了防止这种情况出现，我们通常会对输入信号进行“补零”（zero-padding）操作。对于图示输入，我们会在“1”的左边和“7”的右边各添加个数字“0”。如图 2-5 所示，如此一来输入信号的长度便增加了2，因此对应的输出信号长度也随之增加。补零操作让输出信号和输入信号的长度能够保持一致，更有甚者，如果我们对图示中输入信号的左右两边各添加两个“0”，输出信号的长度则大于输入信号。一般来说，在输入信号一边补零的个数要小于卷积核的长度。这是因为当长度超过或等于卷积核时，卷积所得的结果为0，相当于给输出信号也进行了补零操作，没有意义。更为直观的补零操作可以见二维卷积。\n",
    "\n",
    "\n",
    "<center>\n",
    "    <img style=\"border-radius: 0.3125em;\" \n",
    "    src=\"zero.png\" width=500>\n",
    "    <br>\n",
    "    <div style=\"color:orange; \n",
    "    display: inline-block;\n",
    "    color: #999;\n",
    "    padding: 2px;\">图2-5 输入信号的补零示意 </div>\n",
    "</center>\n",
    "\n",
    "\n",
    "\n",
    "根据以上定义，我们可以得出离散函数一维卷积的计算步骤：\n",
    "\n",
    "1. 变换：改变输入函数的横坐标，自变量由$x$变成$\\tau$；\n",
    "2. 反转：将其中一个函数反转；\n",
    "3. 平移：反转后的函数随变量$\\tau$平移，得到$k_n[x-\\tau]$。若$\\tau>0$，则向右平移，反之向左平移，且$\\tau$为整数；\n",
    "4. 相乘：将$f_n[\\tau]$和$k_n[x-\\tau]$相乘；\n",
    "5. 累加：$f_n[\\tau]$和$k_n[x-\\tau]$乘积和的累加值即为在$x$位置的卷积值。\n",
    "\n",
    "\n",
    "在之后的介绍中，为了方便，我们将连续信号和离散信号统一记作$f$而非$f_n$。接下来，我们将动手编写一维卷积函数。为了更直观的展示卷积的结果，我们用数组表示离散函数，并对输入信号补零，补零的个数为卷积核长度减一，输出信号的长度为$m+2(n-1) - n + 1 = m+n-1$。我们首先用一个方波信号作为卷积核，对一个三角波信号进行卷积。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "\n",
    "# 一维卷积\n",
    "class conv_1d():\n",
    "    def __init__(self, a, b):\n",
    "        self.a = a  # 输入信号\n",
    "        self.b = b  # 卷积核\n",
    "        self.ax = [i for i in range(len(a))]  # 输入信号的坐标，默认从0开始\n",
    "        self.bx = [i for i in range(len(b))]  # 卷积核的坐标，默认从0开始\n",
    "\n",
    "    def conv(self):\n",
    "        lst1 = self.a\n",
    "        lst2 = self.b\n",
    "        l1 = len(lst1)\n",
    "        l2 = len(lst2)\n",
    "        lst1 = [0] * (l2 - 1) + lst1 + [0] * (l2 - 1)\n",
    "        lst2.reverse()\n",
    "        c = [0 for x in range(0, l1 + l2 - 1)]\n",
    "        for i in range(l1 + l2 - 1):\n",
    "            for j in range(l2):\n",
    "                c[i] += lst1[i + j] * lst2[j]\n",
    "        return c\n",
    "\n",
    "    def plot(self):\n",
    "        a = self.a\n",
    "        b = self.b\n",
    "        ax = self.ax\n",
    "        bx = self.bx\n",
    "\n",
    "        # 为了更直观的查看结果，我们分别绘制a、b与它们卷积得到的信号\n",
    "        plt.figure(1)\n",
    "        plt.subplot(1, 2, 1)  # 图一包含1行2列子图，当前画在第一行第一列图上\n",
    "        plt.title('Input')\n",
    "        plt.bar(ax, a, color='lightcoral', width=0.2)\n",
    "        plt.plot(ax, a, color='lightcoral')\n",
    "\n",
    "        plt.figure(1)\n",
    "        plt.subplot(1, 2, 2)  # 当前画在第一行第2列图上\n",
    "        plt.title('Kernel')\n",
    "        plt.bar(bx, b, color='lightgreen', width=0.2)\n",
    "        #plt.plot(bx, b, color='lightgreen')\n",
    "\n",
    "\n",
    "        # 计算输出信号以及其坐标，并画图\n",
    "        c = self.conv()\n",
    "        length = len(c)\n",
    "        cx = [i for i in range(length)]\n",
    "        plt.figure()\n",
    "        plt.title('Convolutional Result')\n",
    "        plt.bar(cx, c, color='lightseagreen', width=0.2)\n",
    "        plt.plot(cx, c, color='lightseagreen')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.2.1 冲激信号"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 定义输入信号与卷积核\n",
    "a = [0,1,2,3,2,1,0]\n",
    "\n",
    "# 冲激函数\n",
    "k = [0,0,1,0,0]\n",
    "\n",
    "conv = conv_1d(a, k)\n",
    "conv.plot()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "当我们所用的卷积核是一个单位冲激信号（即“面积”等于1只在一个位置出现的窄脉冲）时，输入信号在卷积之后并没有发生变化。这是卷积的一个重要性质，请大家记住。下面我们更换一下卷积核，看看输出会有什么不同的效果。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.2.2 方波信号"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 定义输入信号与卷积核\n",
    "a = [0,1,2,3,2,1,0]\n",
    "# 方波信号\n",
    "k = [1,1,1,1,1]\n",
    "\n",
    "conv = conv_1d(a, k)\n",
    "conv.plot()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "大家是否注意到，用一个方波信号对一个三角波信号进行卷积，其效果是将三角波变得平滑了。请大家记住这个现象，后续我们会再次提到。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "同加减乘除一样，卷积作为一种计算操作，也有如下几种性质：\n",
    "1. 交换律：$f(x) * k(x) = k(x) * f(x)$；\n",
    "2. 结合律：$[f(x) * g(x)] * k(x) = f(x) * [g(x) * k(x)]$；\n",
    "3. 分配律：$f(x) * [g(x) + k(x)] = f(x) * g(x) + f(x) * k(x)$。\n",
    "\n",
    "<!-- 4. 微分:$\\frac{d}{dx}[f(x) * k(x)] = \\frac{df(x)}{dx} * k(x) = f(x) * \\frac{dk(x)}{dx}$ -->"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "实际上，在python中，卷积函数可以调用已有的库函数。在接下来的二维卷积中，我们将直接使用库函数（cv2.filter2D）进行卷积操作。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.3 二维卷积"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在计算机视觉领域，我们常常需要对图像进行处理，而卷积则是一种常用的处理操作。一张数字图像可以看作一个二维空间的离散函数，表示为$f[x, y]$。假设图像高为$H$，宽为$W$，设置卷积核$k[x,y]$，可以得到二维卷积的公式：\n",
    "$$g[i,j] = f[x,y] * k[x,y] = \\sum_{m=1}^{H}\\sum_{n=1}^{W}f[m,n]k[i-m,j-n]$$\n",
    "\n",
    "我们将卷积的概念从一维扩展到二维，其结果非常类似，只不过变成了矩阵的“卷和”操作。卷和就是离散的卷积，卷积是积分，而卷和是点与点的乘法和加法。一个二维图像 (矩阵) 同一个二维卷积核卷积的过程是这样的：\n",
    "1. 将二维卷积核对应的矩阵水平翻转，竖直翻转。\n",
    "2. 把这个卷积核矩阵，覆盖到图像上方。\n",
    "3. 将卷积核矩阵的每一个元素，同下方图像的每一个元素相乘，再把所有的乘积加起来，并不断移动这个卷积核矩阵。\n",
    "\n",
    "图 2-6 和图 2-7 描述了二维卷积的计算过程：\n",
    "\n",
    "<center>\n",
    "    <img style=\"border-radius: 0.3125em;\" \n",
    "    src=\"2w1.png\" width=500>\n",
    "    <br>\n",
    "    <div style=\"color:orange; \n",
    "    display: inline-block;\n",
    "    color: #999;\n",
    "    padding: 2px;\">图2-6 二维卷积示意 </div>\n",
    "</center>\n",
    "\n",
    "<center>\n",
    "    <img style=\"border-radius: 0.3125em;\" \n",
    "    src=\"2w2.png\" width=500>\n",
    "    <br>\n",
    "    <div style=\"color:orange; \n",
    "    display: inline-block;\n",
    "    color: #999;\n",
    "    padding: 2px;\">图2-7 二维卷积示意 </div>\n",
    "</center>\n",
    "\n",
    "\n",
    "不难发现，由于卷积核的大小限制，我们没法直接对左上角的像素点“1”进行卷积操作。因此，在计算最边缘的一行和一列的输出结果时，我们一般对原矩阵外围补零，再进行矩阵的卷和操作。\n",
    "\n",
    "<center>\n",
    "    <img style=\"border-radius: 0.3125em;\" \n",
    "    src=\"2w3.png\" width=500>\n",
    "    <br>\n",
    "    <div style=\"color:orange; \n",
    "    display: inline-block;\n",
    "    color: #999;\n",
    "    padding: 2px;\">图2-8 二维卷积补零示意 </div>\n",
    "</center>\n",
    "\n",
    "\n",
    "\n",
    "接下来，我们开始编写二维卷积。我们将对一张图像进行处理，并直观的展示卷积前后图像的变化。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "from PIL import Image\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import cv2\n",
    "import torch\n",
    "from torch.nn import functional as F\n",
    "\n",
    "class conv_2d():\n",
    "    def __init__(self, image, kernel):\n",
    "        self.img = image\n",
    "        self.k = kernel\n",
    "        \n",
    "    def plot(self):\n",
    "        # 展示原图\n",
    "        plt.figure()\n",
    "        plt.imshow(self.img, cmap='gray')\n",
    "        plt.axis('off')\n",
    "        plt.title('Input')\n",
    "    \n",
    "\n",
    "    # 定义二维卷积\n",
    "    def convolution(self, data, k):\n",
    "        # 直接调用库函数进行卷积操作\n",
    "        return cv2.filter2D(data, -1, k)\n",
    "\n",
    "    \n",
    "    # 展示二维卷积结果\n",
    "    def plot_conv(self):\n",
    "        img_new = self.convolution(self.img, self.k)  # 卷积过程\n",
    "        # 卷积结果可视化            \n",
    "        plt.figure()\n",
    "        plt.imshow(img_new, cmap='gray')\n",
    "        plt.title('Output')\n",
    "        plt.axis('off')\n",
    "        return\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.3.1 冲激信号"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "img = Image.open('lena.jpeg')\n",
    "img = img.convert('L')\n",
    "img = np.array(img)\n",
    "# 二维冲激卷积核\n",
    "k1 = np.array([\n",
    "    [0,0,0],\n",
    "    [0,1,0],\n",
    "    [0,0,0]\n",
    "])\n",
    "\n",
    "# 展示原图\n",
    "conv = conv_2d(img, k1)\n",
    "conv.plot()\n",
    "# 也可以使用 conv.plot_RGB() 展示三通道的图像\n",
    "\n",
    "# 展示卷积结果\n",
    "conv.plot_conv()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "由结果可见，用二维冲激函数对图像进行卷积，得到的结果和原图是一样的。这与我们在一维卷积中得到的结果一致。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.3.2 方波信号"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 二维方波卷积核\n",
    "size = 15\n",
    "k = 1/size/size *np.ones((size, size))\n",
    "\n",
    "# 展示原图\n",
    "conv = conv_2d(img, k)\n",
    "conv.plot()\n",
    "\n",
    "# 展示卷积结果\n",
    "conv.plot_conv()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "由结果可见，用方波信号作为卷积核，对图像做卷积，得到的结果是平滑模糊的图像，这也与我们在一维卷积中的实验结果一致。这是不是有一些图像处理的味道了？请大家记住这个结果，我们将在之后的章节中进一步阐述其原理。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.4 总结 "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "卷积是信号处理领域的重要操作，也是计算机视觉中的必备技术。在图像处理中，卷积不仅考虑某一个像素点的影响，还考虑周围像素点对其的作用与影响，这也使得卷积操作为滤波技术奠定了基础。卷积除了一维和二维，同样也有高维的处理方式，感兴趣的同学可以自行查阅相关资料。\n",
    "\n",
    "在接下来的章节中，我们会进一步介绍卷积在图像处理中的作用。\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
